home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / check.py < prev    next >
Encoding:
Python Source  |  2009-10-09  |  31.4 KB  |  897 lines
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # (c) Copyright 2003-2009 Hewlett-Packard Development Company, L.P.
  5. #
  6. # This program is free software; you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation; either version 2 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program; if not, write to the Free Software
  18. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19. #
  20. # Author: Don Welch
  21. #
  22.  
  23. __version__ = '14.3'
  24. __title__ = 'Dependency/Version Check Utility'
  25. __mod__ = 'hp-check'
  26. __doc__ = """Check the existence and versions of HPLIP dependencies. (Run as 'python ./check.py' from the HPLIP tarball before installation.)"""
  27.  
  28. # Std Lib
  29. import sys
  30. import os
  31. import getopt
  32. import commands
  33. import re
  34.  
  35. # Local
  36. from base.g import *
  37. from base import utils, tui, models
  38. from installer import dcheck
  39. from installer.core_install import *
  40.  
  41. device_avail = False
  42. try:
  43.     from base import device, pml
  44.     # This can fail due to hpmudext not being present
  45. except ImportError:
  46.     log.debug("Device library is not avail.")
  47. else:
  48.     device_avail = True
  49.  
  50.  
  51. USAGE = [(__doc__, "", "name", True),
  52.          ("Usage: %s [OPTIONS]" % __mod__, "", "summary", True),
  53.          utils.USAGE_OPTIONS,
  54.          ("Compile-time check:", "-c or --compile", "option", False),
  55.          ("Run-time check:", "-r or --run", "option", False),
  56.          ("Compile and run-time checks:", "-b or --both (default)", "option", False),
  57.          utils.USAGE_LOGGING1, utils.USAGE_LOGGING2, utils.USAGE_LOGGING3,
  58.          utils.USAGE_LOGGING_PLAIN,
  59.          utils.USAGE_HELP,
  60.          utils.USAGE_NOTES,
  61.          ("1. For checking for the proper build environment for the HPLIP supplied tarball (.tar.gz or .run),", "", "note", False),
  62.          ("use the --compile or --both switches.", "", "note", False),
  63.          ("2. For checking for the proper runtime environment for a distro supplied package (.deb, .rpm, etc),", "", "note", False),
  64.          ("use the --runtime switch.", "", "note", False),
  65.         ]
  66.  
  67. def usage(typ='text'):
  68.     if typ == 'text':
  69.         utils.log_title(__title__, __version__)
  70.  
  71.     utils.format_text(USAGE, typ, __title__, __mod__, __version__)
  72.     sys.exit(0)
  73.  
  74.  
  75. build_str = "HPLIP will not build, install, and/or function properly without this dependency."
  76.  
  77. pat_deviceuri = re.compile(r"""(.*):/(.*?)/(\S*?)\?(?:serial=(\S*)|device=(\S*)|ip=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}[^&]*)|zc=(\S+))(?:&port=(\d))?""", re.I)
  78. #pat_deviceuri = re.compile(r"""(.*):/(.*?)/(\S*?)\?(?:serial=(\S*)|device=(\S*)|ip=(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}[^&]*))(?:&port=(\d))?""", re.I)
  79.  
  80. pat_cups_error_log = re.compile("""^loglevel\s?(debug|debug2|warn|info|error|none)""", re.I)
  81.  
  82.  
  83. def parseDeviceURI(device_uri):
  84.     m = pat_deviceuri.match(device_uri)
  85.  
  86.     if m is None:
  87.         raise Error(ERROR_INVALID_DEVICE_URI)
  88.  
  89.     back_end = m.group(1).lower() or ''
  90.     is_hp = (back_end in ('hp', 'hpfax', 'hpaio'))
  91.     bus = m.group(2).lower() or ''
  92.  
  93.     if bus not in ('usb', 'net', 'bt', 'fw', 'par'):
  94.         raise Error(ERROR_INVALID_DEVICE_URI)
  95.  
  96.     model = m.group(3) or ''
  97.     serial = m.group(4) or ''
  98.     dev_file = m.group(5) or ''
  99.     host = m.group(6) or ''
  100.     zc = ''
  101.     if not host:
  102.         zc = host = m.group(7) or ''
  103.     port = m.group(8) or 1
  104.  
  105.     if bus == 'net':
  106.         try:
  107.             port = int(port)
  108.         except (ValueError, TypeError):
  109.             port = 1
  110.  
  111.         if port == 0:
  112.             port = 1
  113.  
  114. #   log.debug("%s: back_end '%s' is_hp '%s' bus '%s' model '%s' serial '%s' dev_file '%s' host '%s' zc '%s' port '%s' " %
  115. #       (device_uri, back_end, is_hp, bus, model, serial, dev_file, host, zc, port))
  116.  
  117.     return back_end, is_hp, bus, model, serial, dev_file, host, zc, port
  118.  
  119. num_errors = 0
  120. fmt = True
  121. overall_commands_to_run = []
  122. time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
  123.  
  124. try:
  125.     log.set_module(__mod__)
  126.  
  127.     try:
  128.         opts, args = getopt.getopt(sys.argv[1:], 'hl:gtcrb',
  129.             ['help', 'help-rest', 'help-man', 'help-desc', 'logging=',
  130.              'run', 'runtime', 'compile', 'both'])
  131.  
  132.     except getopt.GetoptError, e:
  133.         log.error(e.msg)
  134.         usage()
  135.         sys.exit(1)
  136.  
  137.     if os.getenv("HPLIP_DEBUG"):
  138.         log.set_level('debug')
  139.  
  140.     log_level = 'info'
  141.  
  142.     for o, a in opts:
  143.         if o in ('-h', '--help'):
  144.             usage()
  145.  
  146.         elif o == '--help-rest':
  147.             usage('rest')
  148.  
  149.         elif o == '--help-man':
  150.             usage('man')
  151.  
  152.         elif o == '--help-desc':
  153.             print __doc__,
  154.             sys.exit(0)
  155.  
  156.         elif o in ('-l', '--logging'):
  157.             log_level = a.lower().strip()
  158.  
  159.         elif o == '-g':
  160.             log_level = 'debug'
  161.  
  162.         elif o == '-t':
  163.             fmt = False
  164.  
  165.         elif o in ('-c', '--compile'):
  166.             time_flag = DEPENDENCY_COMPILE_TIME
  167.  
  168.         elif o in ('-r', '--runtime', '--run'):
  169.             time_flag = DEPENDENCY_RUN_TIME
  170.  
  171.         elif o in ('-b', '--both'):
  172.             time_flag = DEPENDENCY_RUN_AND_COMPILE_TIME
  173.  
  174.     if not log.set_level(log_level):
  175.         usage()
  176.  
  177.     if not fmt:
  178.         log.no_formatting()
  179.  
  180.     utils.log_title(__title__, __version__)
  181.  
  182.     log.info(log.bold("Note: hp-check can be run in three modes:"))
  183.  
  184.     for l in tui.format_paragraph("1. Compile-time check mode (-c or --compile): Use this mode before compiling the HPLIP supplied tarball (.tar.gz or .run) to determine if the proper dependencies are installed to successfully compile HPLIP."):
  185.         log.info(l)
  186.  
  187.     for l in tui.format_paragraph("2. Run-time check mode (-r or --run): Use this mode to determine if a distro supplied package (.deb, .rpm, etc) or an already built HPLIP supplied tarball has the proper dependencies installed to successfully run."):
  188.         log.info(l)
  189.  
  190.     for l in tui.format_paragraph("3. Both compile- and run-time check mode (-b or --both) (Default): This mode will check both of the above cases (both compile- and run-time dependencies)."):
  191.         log.info(l)
  192.  
  193.     log.info()
  194.  
  195.     log_file = os.path.normpath('./hp-check.log')
  196.     log.info(log.bold("Saving output in log file: %s" % log_file))
  197.     log.debug("Log file=%s" % log_file)
  198.     if os.path.exists(log_file):
  199.         os.remove(log_file)
  200.  
  201.     log.set_logfile(log_file)
  202.     log.set_where(log.LOG_TO_CONSOLE_AND_FILE)
  203.  
  204.     log.info("\nInitializing. Please wait...")
  205.     core =  CoreInstall(MODE_CHECK)
  206.     core.init()
  207.     core.set_plugin_version()
  208.  
  209.     tui.header("SYSTEM INFO")
  210.  
  211.     log.info(log.bold("Basic system information:"))
  212.     log.info(core.sys_uname_info)
  213.  
  214.     log.info()
  215.     log.info(log.bold("Distribution:"))
  216.     log.info("%s %s" % (core.distro_name, core.distro_version))
  217.  
  218.     #log.info(log.bold("\nHPOJ running?"))
  219.  
  220.     #if core.hpoj_present:
  221.         #log.error("Yes, HPOJ is running. HPLIP is not compatible with HPOJ. To run HPLIP, please remove HPOJ.")
  222.         #num_errors += 1
  223.     #else:
  224.         #log.info("No, HPOJ is not running (OK).")
  225.  
  226.  
  227.     log.info()
  228.     log.info(log.bold("Checking Python version..."))
  229.     ver = sys.version_info
  230.     log.debug("sys.version_info = %s" % repr(ver))
  231.     ver_maj = ver[0]
  232.     ver_min = ver[1]
  233.     ver_pat = ver[2]
  234.  
  235.     if ver_maj == 2:
  236.         if ver_min >= 1:
  237.             log.info("OK, version %d.%d.%d installed" % ver[:3])
  238.         else:
  239.             log.error("Version %d.%d.%d installed. Please update to Python >= 2.1" % ver[:3])
  240.             sys.exit(1)
  241.  
  242.     ui_toolkit = sys_conf.get('ui_toolkit', 'qt4')
  243.     if  ui_toolkit == 'qt3':
  244.         log.info()
  245.         log.info(log.bold("Checking PyQt 3.x version..."))
  246.  
  247.         # PyQt 3
  248.         try:
  249.             import qt
  250.         except ImportError:
  251.             num_errors += 1
  252.             log.error("NOT FOUND OR FAILED TO LOAD!")
  253.         else:
  254.             # check version of Qt
  255.             qtMajor = int(qt.qVersion().split('.')[0])
  256.  
  257.             if qtMajor < MINIMUM_QT_MAJOR_VER:
  258.                 log.error("Incorrect version of Qt installed. Ver. 3.0.0 or greater required.")
  259.             else:
  260.                 #check version of PyQt
  261.                 try:
  262.                     pyqtVersion = qt.PYQT_VERSION_STR
  263.                 except AttributeError:
  264.                     pyqtVersion = qt.PYQT_VERSION
  265.  
  266.                 while pyqtVersion.count('.') < 2:
  267.                     pyqtVersion += '.0'
  268.  
  269.                 (maj_ver, min_ver, pat_ver) = pyqtVersion.split('.')
  270.  
  271.                 if pyqtVersion.find('snapshot') >= 0:
  272.                     log.error("A non-stable snapshot version of PyQt is installed (%s)." % pyqtVersion)
  273.                     num_errors += 1
  274.                 else:
  275.                     try:
  276.                         maj_ver = int(maj_ver)
  277.                         min_ver = int(min_ver)
  278.                         pat_ver = int(pat_ver)
  279.                     except ValueError:
  280.                         maj_ver, min_ver, pat_ver = 0, 0, 0
  281.  
  282.                     if maj_ver < MINIMUM_PYQT_MAJOR_VER or \
  283.                         (maj_ver == MINIMUM_PYQT_MAJOR_VER and min_ver < MINIMUM_PYQT_MINOR_VER):
  284.                         num_errors += 1
  285.                         log.error("HPLIP may not function properly with the version of PyQt that is installed (%d.%d.%d)." % (maj_ver, min_ver, pat_ver))
  286.                         log.error("Ver. %d.%d or greater required." % (MINIMUM_PYQT_MAJOR_VER, MINIMUM_PYQT_MINOR_VER))
  287.                     else:
  288.                         log.info("OK, version %d.%d installed." % (maj_ver, min_ver))
  289.             del qt
  290.  
  291.  
  292.     else:
  293.  
  294.         log.info()
  295.         log.info(log.bold("Checking PyQt 4.x version..."))
  296.  
  297.         # PyQt 4
  298.         try:
  299.             import PyQt4
  300.         except ImportError:
  301.             num_errors += 1
  302.             log.error("NOT FOUND OR FAILED TO LOAD!")
  303.         else:
  304.             from PyQt4 import QtCore
  305.             log.info("OK, version %s installed." % QtCore.PYQT_VERSION_STR)
  306.  
  307.  
  308. #    log.info()
  309. #    log.info(log.bold("Checking SIP version..."))
  310. #
  311. #    sip_ver = None
  312. #    try:
  313. #        import pyqtconfig
  314. #    except ImportError:
  315. #        pass
  316. #    else:
  317. #        sip_ver = pyqtconfig.Configuration().sip_version_str
  318. #
  319. #    if sip_ver is not None:
  320. #        log.info("OK, Version %s installed" % sip_ver)
  321. #    else:
  322. #        num_errors += 1
  323. #        log.error("SIP not installed or version not found.")
  324.  
  325.     log.info()
  326.     log.info(log.bold("Checking for CUPS..."))
  327.     cups_ok = True
  328.  
  329.     status, output = utils.run('lpstat -r')
  330.     if status == 0:
  331.         log.info("Status: %s" % output.strip())
  332.     else:
  333.         log.error("Status: (Not available. CUPS may not be installed or not running.)")
  334.         cups_ok = False
  335.         num_errors += 1
  336.  
  337.     if cups_ok:
  338.         status, output = utils.run('cups-config --version')
  339.         if status == 0:
  340.             log.info("Version: %s" % output.strip())
  341.         else:
  342.             log.error("Version: (Not available. CUPS may not be installed or not running.)")
  343.             cups_ok = False
  344.             num_errors += 1
  345.  
  346.     if cups_ok:
  347.         cups_conf = '/etc/cups/cupsd.conf'
  348.  
  349.         try:
  350.             f = file(cups_conf, 'r')
  351.         except (IOError, OSError):
  352.             log.warn("%s file not found or not accessible." % cups_conf)
  353.         else:
  354.             for l in f:
  355.                 m = pat_cups_error_log.match(l)
  356.                 if m is not None:
  357.                     level = m.group(1).lower()
  358.                     log.info("error_log is set to level: %s" % level)
  359.  
  360.                     #if level not in ('debug', 'debug2'):
  361.                         #log.note("For troubleshooting printing issues, it is best to have the CUPS 'LogLevel'")
  362.                         #log.note("set to 'debug'. To set the LogLevel to debug, edit the file %s (as root)," % cups_conf)
  363.                         #log.note("and change the line near the top of the file that begins with 'LogLevel' to read:")
  364.                         #log.note("LogLevel debug")
  365.                         #log.note("Save the file and then restart CUPS (see your OS/distro docs on how to restart CUPS).")
  366.                         #log.note("Now, when you print, helpful debug information will be saved to the file:")
  367.                         #log.note("/var/log/cups/error_log")
  368.                         #log.note("You can monitor this file by running this command in a console/shell:")
  369.                         #log.note("tail -f /var/log/cups/error_log")
  370.  
  371.                     break
  372.  
  373.  
  374.     log.info()
  375.  
  376.     log.info(log.bold("Checking for dbus/python-dbus..."))
  377.  
  378.     if dcheck.check_ps(['dbus-daemon']):
  379.         log.info("dbus daemon is running.")
  380.     else:
  381.         log.warn("dbus daemon is not running.")
  382.  
  383.     try:
  384.         import dbus
  385.         try:
  386.             log.info("python-dbus version: %s" % dbus.__version__)
  387.         except AttributeError:
  388.             try:
  389.                 log.info("python-dbus version: %s" % '.'.join([str(x) for x in dbus.version]))
  390.             except AttributeError:
  391.                 log.warn("python-dbus imported OK, but unknown version.")
  392.     except ImportError:
  393.         log.warn("python-dbus not installed.")
  394.  
  395.     log.info()
  396.  
  397.  
  398.     if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME:
  399.         tui.header("COMPILE AND RUNTIME DEPENDENCIES")
  400.         log.note("To check for compile-time only dependencies, re-run hp-check with the -c parameter (ie, hp-check -c).")
  401.         log.note("To check for run-time only dependencies, re-run hp-check with the -r parameter (ie, hp-check -r).")
  402.  
  403.     elif time_flag == DEPENDENCY_COMPILE_TIME:
  404.         tui.header("COMPILE TIME DEPENDENCIES")
  405.  
  406.     elif time_flag == DEPENDENCY_RUN_TIME:
  407.         tui.header("RUNTIME DEPENDENCIES")
  408.  
  409.     log.info()
  410.  
  411.     dd = core.dependencies.keys()
  412.     dd.sort()
  413.     for d in dd:
  414.         if (d == 'pyqt' and ui_toolkit != 'qt3') or \
  415.            (d == 'pyqt4' and ui_toolkit != 'qt4'):
  416.             continue
  417.  
  418.         log.debug("***")
  419.  
  420.         if time_flag == DEPENDENCY_RUN_AND_COMPILE_TIME or time_flag == core.dependencies[d][4]:
  421.  
  422.             log.info(log.bold("Checking for dependency: %s..." % core.dependencies[d][2]))
  423.  
  424.             if core.have_dependencies[d]:
  425.                 log.info("OK, found.")
  426.             else:
  427.                 num_errors += 1
  428.  
  429.                 if core.dependencies[d][4] == DEPENDENCY_RUN_AND_COMPILE_TIME:
  430.                     s = ''
  431.                 elif core.dependencies[d][4] == DEPENDENCY_COMPILE_TIME:
  432.                     s = '/COMPILE TIME ONLY'
  433.  
  434.                 elif core.dependencies[d][4] == DEPENDENCY_RUN_TIME:
  435.                     s = '/RUNTIME ONLY'
  436.  
  437.                 if core.dependencies[d][0]:
  438.                     log.error("NOT FOUND! This is a REQUIRED%s dependency. Please make sure that this dependency is installed before installing or running HPLIP." % s)
  439.                 else:
  440.                     log.warn("NOT FOUND! This is an OPTIONAL%s dependency. Some HPLIP functionality may not function properly." %s)
  441.  
  442.                 if core.distro_supported():
  443.                     packages_to_install, commands = core.get_dependency_data(d)
  444.  
  445.                     commands_to_run = []
  446.  
  447.                     if packages_to_install:
  448.                         package_mgr_cmd = core.get_distro_data('package_mgr_cmd')
  449.  
  450.                         if package_mgr_cmd:
  451.                             packages_to_install = ' '.join(packages_to_install)
  452.                             commands_to_run.append(utils.cat(package_mgr_cmd))
  453.  
  454.                     if commands:
  455.                         commands_to_run.extend(commands)
  456.  
  457.                     overall_commands_to_run.extend(commands_to_run)
  458.  
  459.                     if len(commands_to_run) == 1:
  460.                         log.info("To install this dependency, execute this command:")
  461.                         log.info(commands_to_run[0])
  462.  
  463.                     elif len(commands_to_run) > 1:
  464.                         log.info("To install this dependency, execute these commands:")
  465.                         for c in commands_to_run:
  466.                             log.info(c)
  467.  
  468.  
  469.             log.info()
  470.  
  471.     if time_flag in (DEPENDENCY_RUN_TIME, DEPENDENCY_RUN_AND_COMPILE_TIME):
  472.         tui.header("HPLIP INSTALLATION")
  473.  
  474.         scanning_enabled = utils.to_bool(sys_conf.get('configure', 'scanner-build', '0'))
  475.  
  476.         log.info()
  477.         log.info(log.bold("Currently installed HPLIP version..."))
  478.         v = sys_conf.get('hplip', 'version')
  479.         home = sys_conf.get('dirs', 'home')
  480.  
  481.         if v:
  482.             log.info("HPLIP %s currently installed in '%s'." % (v, home))
  483.  
  484.             log.info()
  485.             log.info(log.bold("Current contents of '/etc/hp/hplip.conf' file:"))
  486.             try:
  487.                 output = file('/etc/hp/hplip.conf', 'r').read()
  488.             except (IOError, OSError), e:
  489.                 log.error("Could not access file: %s" % e.strerror)
  490.             else:
  491.                 log.info(output)
  492.  
  493.             log.info()
  494.             log.info(log.bold("Current contents of '/var/lib/hp/hplip.state' file:"))
  495.             try:
  496.                 output = file(os.path.expanduser('/var/lib/hp/hplip.state'), 'r').read()
  497.             except (IOError, OSError), e:
  498.                 log.error("Could not access file: %s" % e.strerror)
  499.             else:
  500.                 log.info(output)
  501.  
  502.             log.info()
  503.             log.info(log.bold("Current contents of '~/.hplip/hplip.conf' file:"))
  504.             try:
  505.                 output = file(os.path.expanduser('~/.hplip/hplip.conf'), 'r').read()
  506.             except (IOError, OSError), e:
  507.                 log.error("Could not access file: %s" % e.strerror)
  508.             else:
  509.                 log.info(output)
  510.  
  511.         else:
  512.             log.info("Not found.")
  513.  
  514.  
  515.         if device_avail:
  516.             #if prop.par_build:
  517.                 #tui.header("DISCOVERED PARALLEL DEVICES")
  518.  
  519.                 #devices = device.probeDevices(['par'])
  520.  
  521.                 #if devices:
  522.                     #f = tui.Formatter()
  523.                     #f.header = ("Device URI", "Model")
  524.  
  525.                     #for d, dd in devices.items():
  526.                         #f.add((d, dd[0]))
  527.  
  528.                     #f.output()
  529.  
  530.                 #else:
  531.                     #log.info("No devices found.")
  532.  
  533.                     #if not core.have_dependencies['ppdev']:
  534.                         #log.error("'ppdev' kernel module not loaded.")
  535.  
  536.             if prop.usb_build:
  537.                 tui.header("DISCOVERED USB DEVICES")
  538.  
  539.                 devices = device.probeDevices(['usb'])
  540.  
  541.                 if devices:
  542.                     f = tui.Formatter()
  543.                     f.header = ("Device URI", "Model")
  544.  
  545.                     for d, dd in devices.items():
  546.                         f.add((d, dd[0]))
  547.  
  548.                     f.output()
  549.  
  550.                 else:
  551.                     log.info("No devices found.")
  552.  
  553.  
  554.         tui.header("INSTALLED CUPS PRINTER QUEUES")
  555.  
  556.         lpstat_pat = re.compile(r"""(\S*): (.*)""", re.IGNORECASE)
  557.         status, output = utils.run('lpstat -v')
  558.         log.info()
  559.  
  560.         cups_printers = []
  561.         for p in output.splitlines():
  562.             try:
  563.                 match = lpstat_pat.search(p)
  564.                 printer_name = match.group(1)
  565.                 device_uri = match.group(2)
  566.                 cups_printers.append((printer_name, device_uri))
  567.             except AttributeError:
  568.                 pass
  569.  
  570.         log.debug(cups_printers)
  571.  
  572.         if cups_printers:
  573.             #non_hp = False
  574.             for p in cups_printers:
  575.                 printer_name, device_uri = p
  576.  
  577.                 if device_uri.startswith("cups-pdf:/") or \
  578.                     device_uri.startswith('ipp://'):
  579.                     continue
  580.  
  581.                 try:
  582.                     back_end, is_hp, bus, model, serial, dev_file, host, zc, port = \
  583.                         parseDeviceURI(device_uri)
  584.                 except Error:
  585.                     back_end, is_hp, bus, model, serial, dev_file, host, zc, port = \
  586.                         '', False, '', '', '', '', '', '', 1
  587.  
  588.                 #print back_end, is_hp, bus, model, serial, dev_file, host, zc, port
  589.  
  590.                 log.info(log.bold(printer_name))
  591.                 log.info(log.bold('-'*len(printer_name)))
  592.  
  593.                 x = "Unknown"
  594.                 if back_end == 'hpfax':
  595.                     x = "Fax"
  596.                 elif back_end == 'hp':
  597.                     x = "Printer"
  598.  
  599.                 log.info("Type: %s" % x)
  600.  
  601.                 #if is_hp:
  602.                 #    x = 'Yes, using the %s: CUPS backend.' % back_end
  603.                 #else:
  604.                 #    x = 'No, not using the hp: or hpfax: CUPS backend.'
  605.                 #    non_hp = True
  606.  
  607.                 #log.info("Installed in HPLIP?: %s" % x)
  608.                 log.info("Device URI: %s" % device_uri)
  609.  
  610.                 ppd = os.path.join('/etc/cups/ppd', printer_name + '.ppd')
  611.  
  612.                 if os.path.exists(ppd):
  613.                     log.info("PPD: %s" % ppd)
  614.                     nickname_pat = re.compile(r'''\*NickName:\s*\"(.*)"''', re.MULTILINE)
  615.  
  616.                     f = file(ppd, 'r').read(4096)
  617.  
  618.                     try:
  619.                         desc = nickname_pat.search(f).group(1)
  620.                     except AttributeError:
  621.                         desc = ''
  622.  
  623.                     log.info("PPD Description: %s" % desc)
  624.  
  625.                     status, output = utils.run('lpstat -p%s' % printer_name)
  626.                     log.info("Printer status: %s" % output.replace("\n", ""))
  627.  
  628.                     if back_end == 'hpfax' and not 'HP Fax' in desc:
  629.                         num_errors += 1
  630.                         log.error("Incorrect PPD file for fax queue '%s'. Fax queues must use 'HP-Fax-hplip.ppd'." % printer_name)
  631.  
  632.                     elif back_end == 'hp' and 'HP Fax' in desc:
  633.                         num_errors += 1
  634.                         log.error("Incorrect PPD file for a print queue '%s'. Print queues must not use 'HP-Fax-hplip.ppd'." % printer_name)
  635.  
  636.                     elif back_end not in ('hp', 'hpfax'):
  637.                         log.warn("Printer is not HPLIP installed. Printers must use the hp: or hpfax: CUPS backend to function in HPLIP.")
  638.                         num_errors += 1
  639.  
  640.                 if device_avail and is_hp:
  641.                     d = None
  642.                     try:
  643.                         try:
  644.                             d = device.Device(device_uri)
  645.                         except Error:
  646.                             log.error("Device initialization failed.")
  647.                             continue
  648.  
  649.                         plugin = d.mq.get('plugin', PLUGIN_NONE)
  650.                         if plugin in (PLUGIN_REQUIRED, PLUGIN_OPTIONAL):
  651.  
  652.                             if core.check_for_plugin():
  653.                                 if plugin == PLUGIN_REQUIRED:
  654.                                     log.info("Required plug-in status: Installed")
  655.                                 else:
  656.                                     log.info("Optional plug-in status: Installed")
  657.                             else:
  658.                                 num_errors += 1
  659.  
  660.                                 if plugin == PLUGIN_REQUIRED:
  661.                                     log.error("Required plug-in status: Not installed")
  662.                                 else:
  663.                                     log.warn("Optional plug-in status: Not installed")
  664.  
  665.  
  666.                         if bus in ('par', 'usb'):
  667.                             try:
  668.                                 d.open()
  669.                             except Error, e:
  670.                                 log.error(e.msg)
  671.                                 deviceid = ''
  672.                             else:
  673.                                 deviceid = d.getDeviceID()
  674.                                 log.debug(deviceid)
  675.  
  676.                             #print deviceid
  677.                             if not deviceid:
  678.                                 log.error("Communication status: Failed")
  679.                                 #error_code = pml.ERROR_COMMAND_EXECUTION
  680.                                 num_errors += 1
  681.                             else:
  682.                                 log.info("Communication status: Good")
  683.  
  684.                         elif bus == 'net':
  685.                             try:
  686.                                 error_code, deviceid = d.getPML(pml.OID_DEVICE_ID)
  687.                             except Error:
  688.                                 #log.error("Communication with device failed.")
  689.                                 #error_code = pml.ERROR_COMMAND_EXECUTION
  690.                                 pass
  691.  
  692.                             #print error_code
  693.                             if not deviceid:
  694.                                 log.error("Communication status: Failed")
  695.                                 num_errors += 1
  696.                             else:
  697.                                 log.info("Communication status: Good")
  698.  
  699.                     finally:
  700.                         if d is not None:
  701.                             d.close()
  702.  
  703.                 log.info()
  704.  
  705.  
  706.  
  707.         else:
  708.             log.warn("No queues found.")
  709.  
  710.         if scanning_enabled:
  711.             tui.header("SANE CONFIGURATION")
  712.             log.info(log.bold("'hpaio' in '/etc/sane.d/dll.conf'..."))
  713.             try:
  714.                 f = file('/etc/sane.d/dll.conf', 'r')
  715.             except IOError:
  716.                 log.error("'/etc/sane.d/dll.conf' not found. Is SANE installed?")
  717.                 num_errors += 1
  718.             else:
  719.                 found = False
  720.                 for line in f:
  721.                     if 'hpaio' in line:
  722.                         found = True
  723.  
  724.         # Debian/ Ubuntu place hpaio in /etc/sane.d/dll.d/hplip, so lets check there too
  725.  
  726.         if not found:
  727.             log.info(log.bold("'hpaio' in '/etc/sane.d/dll.d/hplip'..."))
  728.             try:
  729.                        f = file('/etc/sane.d/dll.d/hplip', 'r')
  730.                     except IOError:
  731.                        log.error("'/etc/sane.d/dll.d/hplip' not found.")
  732.                        num_errors += 1
  733.                     else:
  734.                         found = False
  735.                         for line in f:
  736.                             if 'hpaio' in line:
  737.                                 found = True
  738.  
  739.                 if found:
  740.                     log.info("OK, found. SANE backend 'hpaio' is properly set up.")
  741.                 else:
  742.                     num_errors += 1
  743.                     log.error("Not found. SANE backend 'hpaio' NOT properly setup (needs to be added to /etc/sane.d/dll.conf).")
  744.  
  745.                 log.info()
  746.                 log.info(log.bold("Checking output of 'scanimage -L'..."))
  747.                 if utils.which('scanimage'):
  748.                     status, output = utils.run("scanimage -L")
  749.                     log.info(output)
  750.                 else:
  751.                     log.error("scanimage not found.")
  752.  
  753.         tui.header("PYTHON EXTENSIONS")
  754.  
  755.         log.info(log.bold("Checking 'cupsext' CUPS extension..."))
  756.         try:
  757.             import cupsext
  758.         except ImportError:
  759.             num_errors += 1
  760.             log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of cupsext.")
  761.         else:
  762.             log.info("OK, found.")
  763.  
  764.         log.info()
  765.         log.info(log.bold("Checking 'pcardext' Photocard extension..."))
  766.         try:
  767.             import pcardext
  768.         except ImportError:
  769.             num_errors += 1
  770.             log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of pcardext.")
  771.         else:
  772.             log.info("OK, found.")
  773.  
  774.         log.info()
  775.         log.info(log.bold("Checking 'hpmudext' I/O extension..."))
  776.         try:
  777.             import hpmudext
  778.             hpmudext_avail = True
  779.         except ImportError:
  780.             hpmudext_avail = False
  781.             num_errors += 1
  782.             log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of hpmudext.")
  783.         else:
  784.             log.info("OK, found.")
  785.  
  786.         if scanning_enabled:
  787.             log.info()
  788.             log.info(log.bold("Checking 'scanext' SANE scanning extension..."))
  789.             try:
  790.                 import scanext
  791.             except ImportError:
  792.                 num_errors += 1
  793.                 log.error("NOT FOUND OR FAILED TO LOAD! Please reinstall HPLIP and check for the proper installation of scanext.")
  794.             else:
  795.                 log.info("OK, found.")
  796.  
  797.                 log.info()
  798.  
  799.  
  800.         if hpmudext_avail:
  801.             lsusb = utils.which('lsusb')
  802.             if lsusb:
  803.                 log.info()
  804.  
  805.                 lsusb = os.path.join(lsusb, 'lsusb')
  806.                 status, output = utils.run("%s -d03f0:" % lsusb)
  807.  
  808.                 if output:
  809.                     tui.header("USB I/O SETUP")
  810.                     log.info(log.bold("Checking for permissions of USB attached printers..."))
  811.  
  812.                     lsusb_pat = re.compile("""^Bus\s([0-9a-fA-F]{3,3})\sDevice\s([0-9a-fA-F]{3,3}):\sID\s([0-9a-fA-F]{4,4}):([0-9a-fA-F]{4,4})(.*)""", re.IGNORECASE)
  813.                     log.debug(output)
  814.  
  815.                     for o in output.splitlines():
  816.                         ok = True
  817.                         match = lsusb_pat.search(o)
  818.  
  819.                         if match is not None:
  820.                             bus, dev, vid, pid, mfg = match.groups()
  821.                             log.info("\nHP Device 0x%x at %s:%s: " % (int(pid, 16), bus, dev))
  822.                             result_code, deviceuri = hpmudext.make_usb_uri(bus, dev)
  823.  
  824.                             if result_code == hpmudext.HPMUD_R_OK:
  825.                                 log.info("    Device URI: %s" %  deviceuri)
  826.                                 d = None
  827.                                 try:
  828.                                     d = device.Device(deviceuri)
  829.                                 except Error:
  830.                                     continue
  831.                                 if not d.supported:
  832.                                     continue
  833.                             else:
  834.                                 log.warn("    Device URI: (Makeuri FAILED)")
  835.                                 continue
  836.  
  837.                             devnode = os.path.join("/", "dev", "bus", "usb", bus, dev)
  838.  
  839.                             if not os.path.exists(devnode):
  840.                                 devnode = os.path.join("/", "proc", "bus", "usb", bus, dev)
  841.  
  842.                             if os.path.exists(devnode):
  843.                                 log.info("    Device node: %s" % devnode)
  844.  
  845.                                 st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, \
  846.                                     st_size, st_atime, st_mtime, st_ctime = \
  847.                                     os.stat(devnode)
  848.  
  849.                                 log.info("    Mode: 0%o" % (st_mode & 0777))
  850.  
  851.                                 getfacl = utils.which('getfacl')
  852.                                 if getfacl:
  853.                                     getfacl = os.path.join(getfacl, "getfacl")
  854.  
  855.                                     status, output = utils.run("%s %s" % (getfacl, devnode))
  856.  
  857.                                     log.info(output)
  858.  
  859.     tui.header("USER GROUPS")
  860.  
  861.     groups = utils.which('groups')
  862.     if groups:
  863.         groups = os.path.join(groups, 'groups')
  864.         status, output = utils.run(groups)
  865.  
  866.         if status == 0:
  867.             log.info(output)
  868.  
  869.  
  870.     tui.header("SUMMARY")
  871.  
  872.     if num_errors:
  873.         if num_errors == 1:
  874.             log.error("1 error or warning.")
  875.         else:
  876.             log.error("%d errors and/or warnings." % num_errors)
  877.  
  878.         if overall_commands_to_run:
  879.             log.info()
  880.             log.info(log.bold("Summary of needed commands to run to satisfy missing dependencies:"))
  881.             for c in overall_commands_to_run:
  882.                 log.info(c)
  883.  
  884.         log.info()
  885.         log.info("Please refer to the installation instructions at:")
  886.         log.info("http://hplip.sourceforge.net/install/index.html\n")
  887.  
  888.     else:
  889.         log.info(log.green("No errors or warnings."))
  890.  
  891. except KeyboardInterrupt:
  892.     log.error("User exit")
  893.  
  894. log.info()
  895. log.info("Done.")
  896.  
  897.